/* eslint-disable operator-linebreak */
/* eslint-disable eqeqeq */
export default {
    /** 对象合并(可实现多层对象深度合并)
        @param {Object} opts 原始参数
        @param {Object} opt 新参数
        @param {Boolean} override 是否合并重置
    */
    extend(opts, opt, override) {
        for (let p in opt) {
            try {
                // Property in destination object set; update its value.
                if (opt[p].constructor == Object) {
                    opts[p] = this.extend(opts[p], opt[p]);
                } else {
                    opts[p] = opt[p];
                }
            } catch (e) {
                // Property in destination object not set; create it and set its value.
                opts[p] = opt[p];
            }
        }
        return opts;
    },
    /**
     * 深拷贝
     * @param {*} obj 
     * @returns 
     */
    deepCopy(obj) {
        return JSON.parse(JSON.stringify(obj))
    },
    /** *判断字符串是否为空
        @param {string} str 变量
    */
    isDefine(str) {
        if (
            str == null ||
            str == '' ||
            str == 'undefined' ||
            str == undefined ||
            str == 'null' ||
            str == '(null)' ||
            str == 'NULL' ||
            typeof str === 'undefined'
        ) {
            return false;
        }
        str = str + '';
        str = str.replace(/\s/g, '');
        if (str == '') {
            return false;
        }
        return true;
    },
    /** *去除字符串中空格
        @param {string} str 字符串
        @param {Boolean} flag {false: 去除前后空格 | true: 去除全部空格}
    */
    space(str, flag) {
        let result;
        result = str.replace(/(^\s+)|(\s+$)/g, '');

        // flag==false -->去除前后空格；flag==true -->去除全部空格
        if (flag) {
            result = result.replace(/\s/g, '');
        }
        return result;
    },
    // 数组去重
    uniq(array) {
        let temp = []; // 一个新的临时数组
        for (let i = 0; i < array.length; i++) {
            if (temp.indexOf(array[i]) == -1) {
                temp.push(array[i]);
            }
        }
        return temp;
    },
    /** 数组根据数组对象中的某个属性值进行排序的方法 
     * 使用例子：newArray.sort(sortBy('number',false)) //表示根据number属性降序排列;若第二个参数不传递，默认表示升序排序
     * @param attr 排序的属性 如number属性
     * @param rev true表示升序排列，false降序排序
     */
    sortBy(attr, rev) {
        // 第二个参数没有传递 默认升序排列
        if (rev == undefined) {
            rev = 1;
        } else {
            rev = (rev) ? 1 : -1;
        }

        return function(a, b) {
            a = a[attr];
            b = b[attr];
            if (a < b) {
                return rev * -1;
            }
            if (a > b) {
                return rev * 1;
            }
            return 0;
        }
    },
    // 复制到剪切板
    copy(str) {
        let save = function(e) {
            e.clipboardData.setData('text/plain', str); // clipboardData对象
            e.preventDefault(); // 阻止默认行为
        };
        document.addEventListener('copy', save);
        return document.execCommand('copy'); // 使文档处于可编辑状态，否则无效
    },
    // 计算对象数组中某个属性合计
    countTotal(arr, keyName) {
        let $total = 0;
        $total = arr.reduce(function(total, currentValue, currentIndex, arr) {
            return currentValue[keyName] ?
                total + currentValue[keyName] :
                total;
        }, 0);
        return $total;
    },
    /** *本地定时缓存
        @param {string} key 存储内容名称
        @param {*} value 存储内容
        @param {Number} time 存储时长(单位：'s')[如：1*60*60*24 (24小时)]
    */
    setLocal(key, value, time) {
        try {
            if (!localStorage) {
                return false;
            }
            if (!time || isNaN(time)) {
                time = 60;
            }
            let cacheExpireDate = new Date() - 1 + time * 1000;
            let cacheVal = { data: value, exp: cacheExpireDate };
            localStorage.setItem(key, JSON.stringify(cacheVal)); // 存入缓存值

            // console.log(key+":存入缓存，"+new Date(cacheExpireDate)+"到期");
        } catch (e) {
            // console.log(e)
        }
    },
    /** 获取缓存 */
    getLocal(key) {
        try {
            if (!localStorage) {
                return false;
            }
            let cacheVal = localStorage.getItem(key);
            let result = JSON.parse(cacheVal);
            let now = new Date() - 1;
            if (!result) {
                return null;
            } // 缓存不存在
            if (now > result.exp) {
                // 缓存过期
                this.remove(key);
                return '';
            }
            // console.log("get cache:"+key);
            return result.data;
        } catch (e) {
            this.removeLocal(key);
            return null;
        }
    },
    /** 移除缓存，一般情况不手动调用，缓存过期自动调用 */
    removeLocal(key) {
        if (!localStorage) {
            return false;
        }
        localStorage.removeItem(key);
    },
    /** 清空所有缓存 */
    clearLocal() {
        if (!localStorage) {
            return false;
        }
        localStorage.clear();
    },
    // 判断是否存在滚动条
    hasScrollbar() {
        return (
            document.body.scrollHeight >
            (window.innerHeight || document.documentElement.clientHeight)
        );
    },
    // 获取滚动条宽度
    getScrollbarWidth() {
        let scrollDiv = document.createElement('div');
        scrollDiv.style.cssText =
            'width: 99px; height: 99px; overflow: scroll; position: absolute; top: -9999px;';
        document.body.appendChild(scrollDiv);
        let scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth;
        document.body.removeChild(scrollDiv);
        return scrollbarWidth;
    },
    /**
     * 设置页面body滚动条是否显示
     * @param {Body} $body body元素
     * @param {Boolean} flag 是否需要关闭页面滚动条
     */
    setScrollbar($body = document.querySelector('body'), flag = true) {
        // 处理显示弹窗时滚动条穿透问题
        let scrollbarWidth = this.getScrollbarWidth();

        if (flag && this.hasScrollbar()) {
            $body.style.cssText = `overflow: hidden; padding-right: ${scrollbarWidth}px;`;
        } else {
            $body.style.cssText = 'overflow: auto; padding-right: 0px;';
        }
    },
    // 判断参数是否是其中之一
    oneOf(value, validList) {
        for (let i = 0; i < validList.length; i++) {
            if (value === validList[i]) {
                return true;
            }
        }
        return false;
    },
    /* istanbul ignore next */
    addClass(el, cls) {
        if (!el) {
            return
        }
        let curClass = el.className;
        const classes = (cls || '').split(' ');

        for (let i = 0, j = classes.length; i < j; i++) {
            const clsName = classes[i];
            if (!clsName) {
                continue
            }

            if (el.classList) {
                el.classList.add(clsName);
            } else {
                if (!hasClass(el, clsName)) {
                    curClass += ' ' + clsName;
                }
            }
        }
        if (!el.classList) {
            el.className = curClass;
        }
    },
    removeClass(el, cls) {
        if (!el || !cls) {
            return
        }
        const classes = cls.split(' ');
        let curClass = ' ' + el.className + ' ';

        for (let i = 0, j = classes.length; i < j; i++) {
            const clsName = classes[i];
            if (!clsName) {
                continue
            }

            if (el.classList) {
                el.classList.remove(clsName);
            } else {
                if (hasClass(el, clsName)) {
                    curClass = curClass.replace(' ' + clsName + ' ', ' ');
                }
            }
        }
        if (!el.classList) {
            el.className = trim(curClass);
        }
    }
}